home *** CD-ROM | disk | FTP | other *** search
/ Mac Easy 2010 May / Mac Life Ubuntu.iso / casper / filesystem.squashfs / usr / include / linux / fuse.h < prev    next >
Encoding:
C/C++ Source or Header  |  2009-09-09  |  7.3 KB  |  422 lines
  1. /*
  2.     FUSE: Filesystem in Userspace
  3.     Copyright (C) 2001-2006  Miklos Szeredi <miklos@szeredi.hu>
  4.  
  5.     This program can be distributed under the terms of the GNU GPL.
  6.     See the file COPYING.
  7. */
  8.  
  9. /*
  10.  * This file defines the kernel interface of FUSE
  11.  *
  12.  * Protocol changelog:
  13.  *
  14.  * 7.9:
  15.  *  - new fuse_getattr_in input argument of GETATTR
  16.  *  - add lk_flags in fuse_lk_in
  17.  *  - add lock_owner field to fuse_setattr_in, fuse_read_in and fuse_write_in
  18.  *  - add blksize field to fuse_attr
  19.  *  - add file flags field to fuse_read_in and fuse_write_in
  20.  *
  21.  * 7.10
  22.  *  - add nonseekable open flag
  23.  */
  24.  
  25. #ifndef _LINUX_FUSE_H
  26. #define _LINUX_FUSE_H
  27.  
  28. #include <asm/types.h>
  29. #include <linux/major.h>
  30.  
  31. /** Version number of this interface */
  32. #define FUSE_KERNEL_VERSION 7
  33.  
  34. /** Minor version number of this interface */
  35. #define FUSE_KERNEL_MINOR_VERSION 10
  36.  
  37. /** The node ID of the root inode */
  38. #define FUSE_ROOT_ID 1
  39.  
  40. /** The major number of the fuse character device */
  41. #define FUSE_MAJOR MISC_MAJOR
  42.  
  43. /** The minor number of the fuse character device */
  44. #define FUSE_MINOR 229
  45.  
  46. /* Make sure all structures are padded to 64bit boundary, so 32bit
  47.    userspace works under 64bit kernels */
  48.  
  49. struct fuse_attr {
  50.     __u64    ino;
  51.     __u64    size;
  52.     __u64    blocks;
  53.     __u64    atime;
  54.     __u64    mtime;
  55.     __u64    ctime;
  56.     __u32    atimensec;
  57.     __u32    mtimensec;
  58.     __u32    ctimensec;
  59.     __u32    mode;
  60.     __u32    nlink;
  61.     __u32    uid;
  62.     __u32    gid;
  63.     __u32    rdev;
  64.     __u32    blksize;
  65.     __u32    padding;
  66. };
  67.  
  68. struct fuse_kstatfs {
  69.     __u64    blocks;
  70.     __u64    bfree;
  71.     __u64    bavail;
  72.     __u64    files;
  73.     __u64    ffree;
  74.     __u32    bsize;
  75.     __u32    namelen;
  76.     __u32    frsize;
  77.     __u32    padding;
  78.     __u32    spare[6];
  79. };
  80.  
  81. struct fuse_file_lock {
  82.     __u64    start;
  83.     __u64    end;
  84.     __u32    type;
  85.     __u32    pid; /* tgid */
  86. };
  87.  
  88. /**
  89.  * Bitmasks for fuse_setattr_in.valid
  90.  */
  91. #define FATTR_MODE    (1 << 0)
  92. #define FATTR_UID    (1 << 1)
  93. #define FATTR_GID    (1 << 2)
  94. #define FATTR_SIZE    (1 << 3)
  95. #define FATTR_ATIME    (1 << 4)
  96. #define FATTR_MTIME    (1 << 5)
  97. #define FATTR_FH    (1 << 6)
  98. #define FATTR_ATIME_NOW    (1 << 7)
  99. #define FATTR_MTIME_NOW    (1 << 8)
  100. #define FATTR_LOCKOWNER    (1 << 9)
  101.  
  102. /**
  103.  * Flags returned by the OPEN request
  104.  *
  105.  * FOPEN_DIRECT_IO: bypass page cache for this open file
  106.  * FOPEN_KEEP_CACHE: don't invalidate the data cache on open
  107.  * FOPEN_NONSEEKABLE: the file is not seekable
  108.  */
  109. #define FOPEN_DIRECT_IO        (1 << 0)
  110. #define FOPEN_KEEP_CACHE    (1 << 1)
  111. #define FOPEN_NONSEEKABLE    (1 << 2)
  112.  
  113. /**
  114.  * INIT request/reply flags
  115.  *
  116.  * FUSE_EXPORT_SUPPORT: filesystem handles lookups of "." and ".."
  117.  */
  118. #define FUSE_ASYNC_READ        (1 << 0)
  119. #define FUSE_POSIX_LOCKS    (1 << 1)
  120. #define FUSE_FILE_OPS        (1 << 2)
  121. #define FUSE_ATOMIC_O_TRUNC    (1 << 3)
  122. #define FUSE_EXPORT_SUPPORT    (1 << 4)
  123. #define FUSE_BIG_WRITES        (1 << 5)
  124.  
  125. /**
  126.  * Release flags
  127.  */
  128. #define FUSE_RELEASE_FLUSH    (1 << 0)
  129.  
  130. /**
  131.  * Getattr flags
  132.  */
  133. #define FUSE_GETATTR_FH        (1 << 0)
  134.  
  135. /**
  136.  * Lock flags
  137.  */
  138. #define FUSE_LK_FLOCK        (1 << 0)
  139.  
  140. /**
  141.  * WRITE flags
  142.  *
  143.  * FUSE_WRITE_CACHE: delayed write from page cache, file handle is guessed
  144.  * FUSE_WRITE_LOCKOWNER: lock_owner field is valid
  145.  */
  146. #define FUSE_WRITE_CACHE    (1 << 0)
  147. #define FUSE_WRITE_LOCKOWNER    (1 << 1)
  148.  
  149. /**
  150.  * Read flags
  151.  */
  152. #define FUSE_READ_LOCKOWNER    (1 << 1)
  153.  
  154. enum fuse_opcode {
  155.     FUSE_LOOKUP       = 1,
  156.     FUSE_FORGET       = 2,  /* no reply */
  157.     FUSE_GETATTR       = 3,
  158.     FUSE_SETATTR       = 4,
  159.     FUSE_READLINK       = 5,
  160.     FUSE_SYMLINK       = 6,
  161.     FUSE_MKNOD       = 8,
  162.     FUSE_MKDIR       = 9,
  163.     FUSE_UNLINK       = 10,
  164.     FUSE_RMDIR       = 11,
  165.     FUSE_RENAME       = 12,
  166.     FUSE_LINK       = 13,
  167.     FUSE_OPEN       = 14,
  168.     FUSE_READ       = 15,
  169.     FUSE_WRITE       = 16,
  170.     FUSE_STATFS       = 17,
  171.     FUSE_RELEASE       = 18,
  172.     FUSE_FSYNC         = 20,
  173.     FUSE_SETXATTR      = 21,
  174.     FUSE_GETXATTR      = 22,
  175.     FUSE_LISTXATTR     = 23,
  176.     FUSE_REMOVEXATTR   = 24,
  177.     FUSE_FLUSH         = 25,
  178.     FUSE_INIT          = 26,
  179.     FUSE_OPENDIR       = 27,
  180.     FUSE_READDIR       = 28,
  181.     FUSE_RELEASEDIR    = 29,
  182.     FUSE_FSYNCDIR      = 30,
  183.     FUSE_GETLK         = 31,
  184.     FUSE_SETLK         = 32,
  185.     FUSE_SETLKW        = 33,
  186.     FUSE_ACCESS        = 34,
  187.     FUSE_CREATE        = 35,
  188.     FUSE_INTERRUPT     = 36,
  189.     FUSE_BMAP          = 37,
  190.     FUSE_DESTROY       = 38,
  191. };
  192.  
  193. /* The read buffer is required to be at least 8k, but may be much larger */
  194. #define FUSE_MIN_READ_BUFFER 8192
  195.  
  196. #define FUSE_COMPAT_ENTRY_OUT_SIZE 120
  197.  
  198. struct fuse_entry_out {
  199.     __u64    nodeid;        /* Inode ID */
  200.     __u64    generation;    /* Inode generation: nodeid:gen must
  201.                    be unique for the fs's lifetime */
  202.     __u64    entry_valid;    /* Cache timeout for the name */
  203.     __u64    attr_valid;    /* Cache timeout for the attributes */
  204.     __u32    entry_valid_nsec;
  205.     __u32    attr_valid_nsec;
  206.     struct fuse_attr attr;
  207. };
  208.  
  209. struct fuse_forget_in {
  210.     __u64    nlookup;
  211. };
  212.  
  213. struct fuse_getattr_in {
  214.     __u32    getattr_flags;
  215.     __u32    dummy;
  216.     __u64    fh;
  217. };
  218.  
  219. #define FUSE_COMPAT_ATTR_OUT_SIZE 96
  220.  
  221. struct fuse_attr_out {
  222.     __u64    attr_valid;    /* Cache timeout for the attributes */
  223.     __u32    attr_valid_nsec;
  224.     __u32    dummy;
  225.     struct fuse_attr attr;
  226. };
  227.  
  228. struct fuse_mknod_in {
  229.     __u32    mode;
  230.     __u32    rdev;
  231. };
  232.  
  233. struct fuse_mkdir_in {
  234.     __u32    mode;
  235.     __u32    padding;
  236. };
  237.  
  238. struct fuse_rename_in {
  239.     __u64    newdir;
  240. };
  241.  
  242. struct fuse_link_in {
  243.     __u64    oldnodeid;
  244. };
  245.  
  246. struct fuse_setattr_in {
  247.     __u32    valid;
  248.     __u32    padding;
  249.     __u64    fh;
  250.     __u64    size;
  251.     __u64    lock_owner;
  252.     __u64    atime;
  253.     __u64    mtime;
  254.     __u64    unused2;
  255.     __u32    atimensec;
  256.     __u32    mtimensec;
  257.     __u32    unused3;
  258.     __u32    mode;
  259.     __u32    unused4;
  260.     __u32    uid;
  261.     __u32    gid;
  262.     __u32    unused5;
  263. };
  264.  
  265. struct fuse_open_in {
  266.     __u32    flags;
  267.     __u32    mode;
  268. };
  269.  
  270. struct fuse_open_out {
  271.     __u64    fh;
  272.     __u32    open_flags;
  273.     __u32    padding;
  274. };
  275.  
  276. struct fuse_release_in {
  277.     __u64    fh;
  278.     __u32    flags;
  279.     __u32    release_flags;
  280.     __u64    lock_owner;
  281. };
  282.  
  283. struct fuse_flush_in {
  284.     __u64    fh;
  285.     __u32    unused;
  286.     __u32    padding;
  287.     __u64    lock_owner;
  288. };
  289.  
  290. struct fuse_read_in {
  291.     __u64    fh;
  292.     __u64    offset;
  293.     __u32    size;
  294.     __u32    read_flags;
  295.     __u64    lock_owner;
  296.     __u32    flags;
  297.     __u32    padding;
  298. };
  299.  
  300. #define FUSE_COMPAT_WRITE_IN_SIZE 24
  301.  
  302. struct fuse_write_in {
  303.     __u64    fh;
  304.     __u64    offset;
  305.     __u32    size;
  306.     __u32    write_flags;
  307.     __u64    lock_owner;
  308.     __u32    flags;
  309.     __u32    padding;
  310. };
  311.  
  312. struct fuse_write_out {
  313.     __u32    size;
  314.     __u32    padding;
  315. };
  316.  
  317. #define FUSE_COMPAT_STATFS_SIZE 48
  318.  
  319. struct fuse_statfs_out {
  320.     struct fuse_kstatfs st;
  321. };
  322.  
  323. struct fuse_fsync_in {
  324.     __u64    fh;
  325.     __u32    fsync_flags;
  326.     __u32    padding;
  327. };
  328.  
  329. struct fuse_setxattr_in {
  330.     __u32    size;
  331.     __u32    flags;
  332. };
  333.  
  334. struct fuse_getxattr_in {
  335.     __u32    size;
  336.     __u32    padding;
  337. };
  338.  
  339. struct fuse_getxattr_out {
  340.     __u32    size;
  341.     __u32    padding;
  342. };
  343.  
  344. struct fuse_lk_in {
  345.     __u64    fh;
  346.     __u64    owner;
  347.     struct fuse_file_lock lk;
  348.     __u32    lk_flags;
  349.     __u32    padding;
  350. };
  351.  
  352. struct fuse_lk_out {
  353.     struct fuse_file_lock lk;
  354. };
  355.  
  356. struct fuse_access_in {
  357.     __u32    mask;
  358.     __u32    padding;
  359. };
  360.  
  361. struct fuse_init_in {
  362.     __u32    major;
  363.     __u32    minor;
  364.     __u32    max_readahead;
  365.     __u32    flags;
  366. };
  367.  
  368. struct fuse_init_out {
  369.     __u32    major;
  370.     __u32    minor;
  371.     __u32    max_readahead;
  372.     __u32    flags;
  373.     __u32    unused;
  374.     __u32    max_write;
  375. };
  376.  
  377. struct fuse_interrupt_in {
  378.     __u64    unique;
  379. };
  380.  
  381. struct fuse_bmap_in {
  382.     __u64    block;
  383.     __u32    blocksize;
  384.     __u32    padding;
  385. };
  386.  
  387. struct fuse_bmap_out {
  388.     __u64    block;
  389. };
  390.  
  391. struct fuse_in_header {
  392.     __u32    len;
  393.     __u32    opcode;
  394.     __u64    unique;
  395.     __u64    nodeid;
  396.     __u32    uid;
  397.     __u32    gid;
  398.     __u32    pid;
  399.     __u32    padding;
  400. };
  401.  
  402. struct fuse_out_header {
  403.     __u32    len;
  404.     __s32    error;
  405.     __u64    unique;
  406. };
  407.  
  408. struct fuse_dirent {
  409.     __u64    ino;
  410.     __u64    off;
  411.     __u32    namelen;
  412.     __u32    type;
  413.     char name[0];
  414. };
  415.  
  416. #define FUSE_NAME_OFFSET offsetof(struct fuse_dirent, name)
  417. #define FUSE_DIRENT_ALIGN(x) (((x) + sizeof(__u64) - 1) & ~(sizeof(__u64) - 1))
  418. #define FUSE_DIRENT_SIZE(d) \
  419.     FUSE_DIRENT_ALIGN(FUSE_NAME_OFFSET + (d)->namelen)
  420.  
  421. #endif /* _LINUX_FUSE_H */
  422.